HttpParam.java

package com.aincc.lib.network.http;

import java.io.File;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.message.BasicNameValuePair;

import com.aincc.lib.network.common.BaseParam;
import com.aincc.lib.network.common.NetworkDefine;
import com.aincc.lib.util.Utils;

/**
 * 
 * <h3><b>HttpRequestParam</b></h3></br>
 * 
 * @author aincc@barusoft.com
 * @version 1.0.0
 * @since 1.0.0
 */
public class HttpParam extends BaseParam
{
	/**
	 * encoding
	 * 
	 * @since 1.0.0
	 */
	protected String encoding = null;

	/**
	 * post method flag
	 * 
	 * @since 1.0.0
	 */
	protected boolean isPostMethod = true;

	/**
	 * using cookie flag
	 * 
	 * @since 1.0.0
	 */
	protected boolean isUseCookie = true;

	/**
	 * exist multipart flag
	 * 
	 * @since 1.0.0
	 */
	protected boolean isExistMultipart = false;

	/**
	 * HTTP header
	 * 
	 * @since 1.0.0
	 */
	protected LinkedHashMap<String, String> header = new LinkedHashMap<String, String>();

	/**
	 * parameter
	 * 
	 * @since 1.0.0
	 */
	protected LinkedHashMap<String, String> param = new LinkedHashMap<String, String>();

	/**
	 * array parameter
	 * 
	 * @since 1.0.0
	 */
	protected LinkedHashMap<String, String[]> paramArray = new LinkedHashMap<String, String[]>();

	/**
	 * file parameter (for POST method)
	 * 
	 * @since 1.0.0
	 */
	protected LinkedHashMap<String, File> fileParam = new LinkedHashMap<String, File>();

	/**
	 * constructor
	 * 
	 * @since 1.0.0
	 * @param requestKey
	 */
	public HttpParam(String requestKey)
	{
		super(requestKey);
		this.encoding = NetworkDefine.ENCODING_EUCKR;
	}

	/**
	 * @return the encoding
	 */
	public String getEncoding()
	{
		return encoding;
	}

	/**
	 * @param encoding
	 *            the encoding to set
	 */
	public void setEncoding(String encoding)
	{
		this.encoding = encoding;
	}

	/**
	 * @return the isPostMethod
	 */
	public boolean isPostMethod()
	{
		return isPostMethod;
	}

	/**
	 * @param isPostMethod
	 *            the isPostMethod to set
	 */
	public void setPostMethod(boolean isPostMethod)
	{
		this.isPostMethod = isPostMethod;
	}

	/**
	 * @return the isUseCookie
	 */
	public boolean isUseCookie()
	{
		return isUseCookie;
	}

	/**
	 * @param isUseCookie
	 *            the isUseCookie to set
	 */
	public void setUseCookie(boolean isUseCookie)
	{
		this.isUseCookie = isUseCookie;
	}

	/**
	 * @return the isExistMultipart
	 */
	public boolean isExistMultipart()
	{
		return isExistMultipart;
	}

	/**
	 * @param isExistMultipart
	 *            the isExistMultipart to set
	 */
	public void setExistMultipart(boolean isExistMultipart)
	{
		this.isExistMultipart = isExistMultipart;
	}

	/**
	 * @return the header
	 */
	public LinkedHashMap<String, String> getHeader()
	{
		return header;
	}

	/**
	 * @param header
	 *            the header to set
	 */
	public void setHeader(LinkedHashMap<String, String> header)
	{
		this.header = header;
	}

	/**
	 * @return the param
	 */
	public LinkedHashMap<String, String> getParam()
	{
		return param;
	}

	/**
	 * @param param
	 *            the param to set
	 */
	public void setParam(LinkedHashMap<String, String> param)
	{
		this.param = param;
	}

	/**
	 * @return the paramArray
	 */
	public LinkedHashMap<String, String[]> getParamArray()
	{
		return paramArray;
	}

	/**
	 * @param paramArray
	 *            the paramArray to set
	 */
	public void setParamArray(LinkedHashMap<String, String[]> paramArray)
	{
		this.paramArray = paramArray;
	}

	/**
	 * @return the fileParam
	 */
	public LinkedHashMap<String, File> getFileParam()
	{
		return fileParam;
	}

	/**
	 * @param fileParam
	 *            the fileParam to set
	 */
	public void setFileParam(LinkedHashMap<String, File> fileParam)
	{
		this.fileParam = fileParam;
		if (null != fileParam && !fileParam.isEmpty())
		{
			setExistMultipart(true);
		}
	}

	/**
	 * get query parameter string
	 * 
	 * @since 1.0.0
	 * @return query parameter string
	 */
	public String getGetParams()
	{
		return getGetParams(this.encoding);
	}

	/**
	 * get query parameter string
	 * 
	 * @since 1.0.0
	 * @param encoding
	 * @return query parameter string
	 */
	public String getGetParams(String encoding)
	{
		StringBuilder sb = new StringBuilder();
		if (null != param && !param.isEmpty())
		{
			String urlEncoderStr = null;

			Set<Entry<String, String>> hashSet = param.entrySet();
			final Iterator<Entry<String, String>> it = hashSet.iterator();
			while (it.hasNext())
			{
				Map.Entry<String, String> me = (Map.Entry<String, String>) it.next();

				urlEncoderStr = null;
				try
				{
					urlEncoderStr = URLEncoder.encode(me.getValue(), encoding);
					urlEncoderStr = urlEncoderStr.replaceAll("\\+", "%20");
				}
				catch (Exception e)
				{
					urlEncoderStr = null;
				}

				if (!Utils.isTrimEmpty(urlEncoderStr))
				{
					if (0 < sb.length())
					{
						sb.append("&");
					}
					sb.append(me.getKey());
					sb.append("=");
					sb.append(urlEncoderStr);
				}
			}
		}
		if (null != paramArray && !paramArray.isEmpty())
		{
			String urlEncoderStr = null;

			Set<Entry<String, String[]>> hashSet = paramArray.entrySet();
			final Iterator<Entry<String, String[]>> it = hashSet.iterator();
			while (it.hasNext())
			{
				Map.Entry<String, String[]> me = (Map.Entry<String, String[]>) it.next();

				String[] values = me.getValue();
				for (int i = 0; i < values.length; i++)
				{
					urlEncoderStr = null;
					try
					{
						urlEncoderStr = URLEncoder.encode(values[i], encoding);
						urlEncoderStr = urlEncoderStr.replaceAll("\\+", "%20");
					}
					catch (Exception e)
					{
						urlEncoderStr = null;
					}

					if (!Utils.isTrimEmpty(urlEncoderStr))
					{
						if (0 < sb.length())
						{
							sb.append("&");
						}
						sb.append(me.getKey());
						sb.append("=");
						sb.append(urlEncoderStr);
					}
				}
			}
		}
		if (0 < sb.length())
		{
			return sb.toString();
		}
		return null;
	}

	/**
	 * get UrlEncodedFormEntity
	 * 
	 * @since 1.0.0
	 * @return UrlEncodedFormEntity
	 */
	public UrlEncodedFormEntity getPostParams()
	{
		return getPostParams(this.encoding);
	}

	/**
	 * get UrlEncodedFormEntity
	 * 
	 * @since 1.0.0
	 * @param encoding
	 * @return UrlEncodedFormEntity
	 */
	public UrlEncodedFormEntity getPostParams(String encoding)
	{
		UrlEncodedFormEntity entity = null;
		List<BasicNameValuePair> paramList = new ArrayList<BasicNameValuePair>();

		if (null != param && !param.isEmpty())
		{
			Set<Entry<String, String>> hashSet = param.entrySet();
			final Iterator<Entry<String, String>> it = hashSet.iterator();
			while (it.hasNext())
			{
				Map.Entry<String, String> me = (Map.Entry<String, String>) it.next();

				paramList.add(new BasicNameValuePair(me.getKey(), me.getValue()));
			}
		}
		if (null != paramArray && !paramArray.isEmpty())
		{
			Set<Entry<String, String[]>> hashSet = paramArray.entrySet();
			final Iterator<Entry<String, String[]>> it = hashSet.iterator();
			while (it.hasNext())
			{
				Map.Entry<String, String[]> me = (Map.Entry<String, String[]>) it.next();
				String[] values = me.getValue();
				for (int i = 0; i < values.length; i++)
				{
					paramList.add(new BasicNameValuePair(me.getKey(), values[i]));
				}
			}
		}

		if (0 < paramList.size())
		{

			try
			{
				entity = new UrlEncodedFormEntity(paramList, encoding);
			}
			catch (Exception e)
			{
				e.printStackTrace();
				entity = null;
			}
		}
		return entity;
	}

	/**
	 * get MultipartEntity
	 * 
	 * @since 1.0.0
	 * @return MultipartEntity
	 */
	public MultipartEntity getMultipartParams()
	{
		return getMultipartParams(this.encoding);
	}

	/**
	 * get MultipartEntity
	 * 
	 * @since 1.0.0
	 * @param encoding
	 * @return MultipartEntity
	 */
	public MultipartEntity getMultipartParams(String encoding)
	{
		MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
		try
		{
			if (null != param && !param.isEmpty())
			{
				Set<Entry<String, String>> hashSet = param.entrySet();
				final Iterator<Entry<String, String>> it = hashSet.iterator();
				while (it.hasNext())
				{
					Map.Entry<String, String> me = (Map.Entry<String, String>) it.next();

					entity.addPart(me.getKey(), new StringBody(me.getValue(), Charset.forName(encoding)));
				}
			}
			if (null != paramArray && !paramArray.isEmpty())
			{
				Set<Entry<String, String[]>> hashSet = paramArray.entrySet();
				final Iterator<Entry<String, String[]>> it = hashSet.iterator();
				while (it.hasNext())
				{
					Map.Entry<String, String[]> me = (Map.Entry<String, String[]>) it.next();
					String[] values = me.getValue();
					for (int i = 0; i < values.length; i++)
					{
						entity.addPart(me.getKey(), new StringBody(values[i], Charset.forName(encoding)));
					}
				}
			}
			if (null != fileParam && !fileParam.isEmpty())
			{
				Set<Entry<String, File>> hashSet = fileParam.entrySet();
				final Iterator<Entry<String, File>> it = hashSet.iterator();
				while (it.hasNext())
				{
					Map.Entry<String, File> me = (Map.Entry<String, File>) it.next();

					entity.addPart(me.getKey(), new FileBody(me.getValue()));
				}
			}
		}
		catch (Exception e)
		{
			e.printStackTrace();
			entity = null;
		}
		return entity;
	}
}